Lambdas

Een lambda is een methode zonder naam. Soms heb je een blok code, die een specifiek doel dient, maar je vind het de moeite niet om die blok code als een methode te definiëren. Methoden zijn ooit geïntroduceerd om je code te modulariseren en hebben iets om naar te verwijzen als ze met delegates gebruikt worden en vanafverschillende plaatsen opgeroepen worden. Maar het gebeurt dat je alleen maar een blok code voor een specifieke operatie wilt uitvoeren zonder daarom een methode te moeten declareren. Lambdas zijn snelle en eenvoudige manieren om een blok code toe te kennen aan een variabele en te laten uit te uitvoeren.

Lambda expressies

De term "Lambda uitdrukking" is ontleend aan "lambda" calculus. Dat is een wiskundige notatie, die gebruikt wordt om functies te definiëren.

Deze lambda expressies hebben de volgende syntax:

(invoerparameters) => expressie of codeblok

Hieronder is een voorbeeld van de lambda-expressie.

y => y * y

De bovenstaande expressie definiëert een parameter met de naam y en die waarde wordt gekwadrateerd. Het is echter niet mogelijk om een lambda-expressie in deze vorm uit te voeren. Een voorbeeld van een lambda-expressie in C # wordt hieronder weergegeven.

We beginnen met enkele delegates te definiëren in de klasse WerkenMetDelegates, die in het bestand WerkenMetDelegates.cs staat in de map App_Code.

namespace CSharpLerenViaConsole
{
    class WerkenMetDelegates
    {
        public delegate float Float1parameter(float x);
        public delegate float Float2parameters(float x, float y);
    }
}

In de Main methode van de Program klasse defiëren we enkele lambda expressies:

namespace CSharpLerenViaConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            WerkenMetDelegates.Float1parameter squareIt = x => x * x; 
            WerkenMetDelegates.Float2parameters multiplyIt = (x, y) => x * y;
            WerkenMetDelegates.Float2parameters sumIt = (x, y) => x + y;
            WerkenMetDelegates.Float2parameters substractIt = (x, y) => x - y;
            WerkenMetDelegates.Float2parameters divideIt = (x, y) => x / y;
        }
    }
}

En we gebruiken die als volgt:

float a = 2.5f;
float b = 3.14f;
Console.WriteLine("De vermenigvuldiging van {0} en {1} is {2}.\n",
        a, b, multiplyIt(a, b));
Console.WriteLine("De som van {0} en {1} is {2}.\n",
    a, b, sumIt(a, b));
Console.WriteLine("De aftrekking van {0} en {1} is {2}.\n",
    a, b, substractIt(a, b));
Console.WriteLine("De deling van {0} en {1} is {2}.\n",
    a, b, divideIt(a, b));
Console.WriteLine("Het kwadraat van {0} en van {1} is {2} en {3}.\n",
    a, b, squareIt(a), squareIt(b));
Console.ReadLine();

Expressie-boom

Lambda-expressies worden veel gebruikt in 'Expression Tree' constructies. Een expressie-boom lijkt op een boom waarin elke node zelf een expressie is, net zoals een methode of een binaire operatie zoals x < y.

Hieronder is een voorbeeld van het gebruik van lambda-expressie voor het construeren van een expressie boom.

decimal[] prices = { 1.25m, 200, 50, 400.3m };
foreach (decimal p in prices.Where(x => x > 100))
{
    Console.WriteLine(p);
}

Je kan hetzelfde doen zonder gebruik te maken van lambda's:

decimal[] prices = { 1.25m, 200, 50, 400.3m };
foreach (decimal p in prices)
{
    if (p > 100)
    {
        Console.WriteLine(p);
    }
}

Bronnen

Florian Rappl, Way to Lambda, 29 Jan 2013

2016-11-23 13:30:48